const path = require('path');
const { app } = require('electron');

class StorageManager {
    constructor(modelName = null, primaryKey = "id") {
        this.modelName = modelName;
        this.primaryKey = primaryKey;
        this.store = null; // 延迟初始化
    }

    async init() {
        const { default: Store } = await import('electron-store'); // 动态导入 ESM 模块
        const isDev = !app.isPackaged;
        const filePath = isDev ? app.getAppPath() : app.getPath('userData');
        this.store = new Store({
            cwd: path.join(filePath, 'localDb'), // ✅ 存储路径
            name: this.modelName || "global_store", // ✅ 指定文件名（默认 global_store）
            //projectName: 'my-project-name' // ✅ 影响存储默认路径，通常不与 cwd 同时使用
        });
    }

    async ensureInit() {
        if (!this.store) {
            await this.init();
        }
    }

    /** 🔍 **获取所有数据**（仅模型模式下生效） */
    async getAll() {
        if (!this.modelName) throw new Error("getAll() 只能用于模型模式");
        await this.ensureInit();
        return await this.store.get(this.modelName, []);
    }

    /** 🔍 **获取数据**（支持模型或普通 key） */
    async get(keyOrId, defaultValue = null) {
        await this.ensureInit();
        if (this.modelName) {
            const allData = await this.getAll();
            if (Array.isArray(allData)) {
                return allData.find(item => item[this.primaryKey] === keyOrId) || defaultValue; // ✅ 按 id 查找
            }
            return defaultValue;
        }
        return await this.store.get(keyOrId, defaultValue);
    }


    /** 📝 **存储数据**（支持模型或普通 key） */
    async set(dataOrKey, value = null) {
        await this.ensureInit();
        try {
            ///1，如果dataOrKey是个数组
            if (this.modelName && Array.isArray(dataOrKey)) {
                const allData = await this.getAll();  // 获取现有数据
                // 使用 Map 来提高效率
                const allDataMap = new Map(allData.map(item => [item[this.primaryKey], item]));
                dataOrKey.forEach(item => {
                    const id = item[this.primaryKey];
                    if (!id) throw new Error(`模型缺少主键 ${this.primaryKey}`);
                    // 更新数据或新增数据
                    allDataMap.set(id, item);  // 如果 id 存在，替换；如果 id 不存在，新增
                });
                // 将 Map 转回数组并保存
                await this.store.set(this.modelName, Array.from(allDataMap.values()));
            }
            ///2，如果dataOrKey是个模型
            else if (this.modelName && typeof dataOrKey === "object") {
                return this.set([dataOrKey], value);
            }
            ///如果dataOrKey是个键值队的key
            else {
                await this.store.set(dataOrKey, value);
            }
            return { success: true };
        } catch (error) {
            return { success: false, error };
        }
    }

    /** ❌ **删除数据**（支持模型或普通 key） */
    async delete(keyOrId) {
        await this.ensureInit();
        try {
            if (this.modelName) {
                const allData = await this.getAll();
                // 使用 filter 删除指定 ID 的元素
                const updatedData = allData.filter(item => item[this.primaryKey] !== keyOrId);
                // 更新存储
                await this.store.set(this.modelName, updatedData);
            } else {
                await this.store.delete(keyOrId);
            }
            return { success: true };
        } catch (error) {
            return { success: false, error };
        }
    }

    /** 🗑️ **清空所有数据**（仅模型模式下生效） */
    async clearAll() {
        await this.ensureInit();
        try {
            if (!this.modelName) throw new Error("clearAll() 只能用于模型模式");
            await this.store.delete(this.modelName);
            return { success: true };
        } catch (error) {
            return { success: false, error };
        }
    }
}

module.exports = StorageManager;
